package com.niit.base

import scala.collection.mutable.{ArrayBuffer, ListBuffer}

object Base_07 {

  def main(args: Array[String]): Unit = {
    /*
      数组：
        1.定长数组
        2.变长数组
        3.数组的修改
        4.数组的遍历
     */
    //定长数组：长度不允许改变 var/val 变量名 = new Array[数据类型](长度)
    var arr1 = new Array[Int](10)// 最大索引值= 长度-1
    var arr2 = Array(10,20,30,40,50)
    println(arr2(2))
    println(arr1(9)) // 0  报错： java.lang.ArrayIndexOutOfBoundsException: 10 10的索引下标越界了
    println(arr1(0))

    //变长数组：长度允许改变  var/val 变量名 = ArrayBuffer[数据类型]()
    import scala.collection.mutable.ArrayBuffer
    var ab1 = ArrayBuffer[Int]()
    var ab2 = ArrayBuffer("Java","JavaScript","Python","Scala","C","MySQL","Hadoop","HBase","HTML-CSS")

    //数组的修改 增 删
    ab2 += "Spark"
    //println(ab2.length,ab2.size,ab2)
    //增加多个数据
    ab2 ++= Array("Kafka","Flume")
    //删
    ab2 -= "HTML-CSS"
    //println(ab2)
    ab2 --= Array("C","Python")
    //println(ab2)

    //遍历数组
//    for (i <- 0 to ab2.length -1 ){// to :闭区间
//      println(ab2(i))
//    }

//    for (i <- 0 until ab2.length  ){// until:左闭右开区间
//      println(ab2(i))
//    }
//    for( i <- ab2){// i 就是数组中的每一个元素 可以直接输出i
//      println(i)
//    }

    /*
    元组：元组一般用来存储不同类型的数据，并且长度和元素都不可变
    1.元组的定义
    2.访问元组中的元素
     */
    //定义元组
//    var tuple1 = ("张三",23,'男')
//    var tuple2 = "李四" -> 23 -> '男'
//    println(tuple1)
//    println(tuple2)
//    //访问元组
//    tuple1._1  //第一个元素
//    println(tuple1._1)
//    //遍历元组，前提 先用元组生成一个迭代器对象 才可以遍历
//    val it = tuple1.productIterator //元素的迭代器
//    for (i <- it){
//      println(i)
//    }

    /*
     列表：特点：有序 可重复
      1.不可变列表
      2.可变列表
      3.列表的扁平化
      4.列表的拉链与拉开
      5.列表的交并差
     */
    //不可变列表 元素和长度都是不可变的
    var list1 = List(3,4,1,4,2,3)
    var list2 = Nil //创建一个不可变空列表
    var list3 = 2 :: -1 :: Nil //使用双冒号方式创建列表 包含了 2 和 -1 元素
    println(list1,list2,list3)
    //可变列表
    import scala.collection.mutable.ListBuffer
    var lb1 = ListBuffer[Int]()
    var lb2 = ListBuffer(1,2,3,4,5)
    lb1 += 10
    lb1 += 30
    lb1 ++= List(10,3,100)
    //转换为不可变列表
    var list4 = lb1.toList
    //转换为列表
    var arr3 =  lb1.toArray
    println(lb1)
    //去重 distinct
    val distinct = lb1.distinct;
    println(distinct)
    //获得首个元素head
    val head = lb1.head
    println(head)
    //获得除首个元素外的其他元素 tail
    val tail = lb1.tail
    println(tail)
    //take :获得从前往后数多少个元素  drop：获得从后往前数多少个元素
    val value = lb1.take(3);
    val value1 = lb1.drop(3)
    println(value,value1)
    //列表的扁平化 嵌套列表中的所有元素 单独放到一个新列表当中
    var list5 = List(List(1,2),List(3,4),List(5))
    val list6 = list5.flatten
    println(list6)
    //拉链: 将两个列表，组成一个元素为元组的列表
    val names = List("张三","李四","王五")
    val ages = List(23,24,25)
    var list7 = names.zip(ages)
    println(list7)
    //拉开:将一个包含元组的列表，拆解成两个列表的元组
    val tu = list7.unzip
    println(tu)
    //列表的交并差
    var list8 = List(1,2,3,4)
    var list9 = List(3,4,5,6)
    //并集
    val value2 = list8.union(list9)
    println(value2.distinct)
    //交集
    val value3 = list8.intersect(list9)
    println(value3)
    //差集
    val value4 = list8.diff(list9)
    println(value4)
  }

}
